home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / plotting / pcgplots / cgmio.h < prev    next >
C/C++ Source or Header  |  1992-04-24  |  15KB  |  398 lines
  1. // C++ .h file for gplot, CGM-specific I/O  -*-c++-*-
  2. // copyright Phil Andrews, Pittsburgh Supercomputing Center, 1992
  3. // all rights reserved
  4. #ifndef cgmio_h
  5. #define cgmio_h
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include "cgm.h"
  9. #if __MSDOS__
  10. #include <io.h>
  11. #endif
  12. #include "basicio.h"
  13. #ifdef macintosh
  14. #  include <UMacApp.h>
  15. #  include <errors.h>
  16. #endif
  17. ////
  18. // definitions for input, output
  19. ////
  20. enum {clearCGM, binaryCGM}; // for identification
  21. ////
  22. // typedef for parsing array
  23. ////
  24. typedef baseCGM *(*parseFp)(cgmContainer*, cgmInput*, baseCGM*);
  25. ////
  26. // structure for parsing table
  27. ////
  28. class cgmNameNew {
  29. public:
  30.   // default constructor, (default arguments not implemented in arrays)
  31.   cgmNameNew() {myName=NULL; myClass=0; myElement=0; fp=NULL;}
  32.   // real constructor
  33.   cgmNameNew(const char **inName, int inClass, int inElement, parseFp inFp)
  34.     {myName=inName; myClass=inClass; myElement=inElement; fp=inFp;}
  35.   const char **myName; // clear text name
  36.   int myClass; // cgm class
  37.   int myElement; // cgm element
  38.   // function to create new element
  39.   parseFp fp;
  40. };
  41. ////
  42. // basic cgm input class
  43. ////
  44. class cgmInput : public basicInput {
  45. public:
  46.   cgmInput(const char *inName, short refHand=0)
  47.      : basicInput(inName, refHand) {initialize();}
  48.   cgmInput(FILE *inPtr, short refHand=0, int offset=0)
  49.      : basicInput(inPtr, refHand, offset) {initialize();}
  50.   void initialize(); // initialize constants
  51.   // the pure virtual functions, required of all descendants
  52.   virtual int isa() = 0;
  53. #if __MSDOS__
  54.   virtual  HugePt getCmd() = 0; // get the next command
  55. #else
  56.   virtual unsigned char *getCmd() = 0; // get the next command
  57. #endif
  58.   virtual char *getString(int&) = 0; // get a string from input
  59.   virtual int getInt(int = 0) = 0; // get an integer from input
  60.   virtual float getReal() = 0; // get a real from input
  61.   virtual float getFP() = 0; // get a floating point real from input
  62.   virtual int getE() = 0; // get an enumerated int
  63.   virtual int getType(const char**, int) = 0; // check for possible types
  64.   virtual void getIntPrec(intPrec*) = 0; // get the integer precision
  65.   virtual void getIntPrec(uIntPrec*) = 0; // get the unsigned integer precision
  66.   virtual void getRealPrec(realPrec*) = 0; // get the real precision
  67.   virtual unsigned int getCD(int = 0) = 0; // direct colour component
  68.   virtual unsigned int getCI(int = 0) = 0; // indexed colour
  69.   virtual int getVIP() = 0; // VDC at integer precision
  70.   virtual float getVRP() = 0; // VDC at real precision
  71.   virtual int getNoPts() = 0; // how many vdc points to come ?
  72.   virtual int polygonSetSize() = 0; // how many  points in the polyset ?
  73.   virtual int getPt(float*) = 0; // get one real vdc point
  74.   virtual int getPt(int*) = 0; // get one integer vdc point
  75.   virtual int getNoDColrs() = 0; // how many direct colours to get
  76.   virtual cgmDefaults *getDefaults(cgmMetafile*) = 0; // get metafile defaults
  77.   virtual const char *cmdSignature() = 0; // diagnostic
  78.   // get a cell array
  79.   virtual cellArray *getCellArray(int, const colrValueExtent*,
  80.                   const colrTable*) = 0;
  81.   ////
  82.   // default functions
  83.   ////
  84.   virtual baseCGM *doCmd(cgmContainer*, baseCGM*); // interpret the command
  85.   // get a direct colour
  86.   virtual void getDColr(dColr&); 
  87.   // get a general colour
  88.   virtual genColr *getColr(int, const colrValueExtent*, const colrTable*); 
  89.   // get a single VDC measure
  90.   virtual vdc *getVdc(); 
  91.   // get a set of VDC points
  92.   virtual vdcPts *getVdcPts(int=0); 
  93.   // get a colour table
  94.   virtual colrTable *getColrTable(const colrValueExtent*);
  95.   virtual int padCmd() {return 0;} // ignore this ?
  96.   virtual void makeIndex(cgmMetafile*); // create an index
  97.   ////
  98.   // values needed for input parsing
  99.   // default values
  100.   intPrec defIntPrec; // default integer precision
  101.   uIntPrec defColrPrec; // default colour precision
  102.   uIntPrec defColrIndexPrec; // default colour index precision
  103.   realPrec defRealPrec; // default real precision
  104.   intPrec defVdcIntPrec; // default VDC integer precision
  105.   realPrec defVdcRealPrec; // default VDC integer precision
  106.   ////
  107.   // overriding commands
  108.   cgmVdcType *vdcTypeCmd; // vdc type, integer or real
  109.   cgmIntegerPrec *intPrecCmd;
  110.   cgmRealPrec *realPrecCmd;
  111.   cgmIndexPrec *indexPrecCmd; // index precision
  112.   cgmColrPrec *colrPrecCmd; // colour precision
  113.   cgmColrIndexPrec *colrIndexPrecCmd; // colour index precision
  114.   cgmVdcInteger *vdcIntPrecCmd, *defVdcIntPrecCmd;
  115.   cgmVdcReal *vdcRealPrecCmd, *defVdcRealPrecCmd;
  116.   ////
  117.   // the functions to get the precisions
  118.   virtual vdcType myVdcType() {return vdcTypeCmd ? vdcTypeCmd->myType : 0;}
  119.   virtual intPrec& myIntPrec()
  120.     {return intPrecCmd ? intPrecCmd->thisPrec : defIntPrec;}
  121.   virtual realPrec& myRealPrec()
  122.     {return realPrecCmd ? realPrecCmd->thisPrec : defRealPrec;}
  123.   virtual intPrec& indexPrec()
  124.     {return indexPrecCmd ? indexPrecCmd->thisPrec : defIntPrec;}
  125.   virtual uIntPrec& colrPrec()
  126.     {return colrPrecCmd ? colrPrecCmd->thisPrec : defColrPrec;}
  127.   virtual uIntPrec& colrIndexPrec()
  128.     {return colrIndexPrecCmd ? colrIndexPrecCmd->thisPrec : defColrIndexPrec;}
  129.   virtual intPrec& vdcIntPrec() 
  130.     {return vdcIntPrecCmd ? vdcIntPrecCmd->thisPrec :
  131.      defVdcIntPrecCmd ? defVdcIntPrecCmd->thisPrec : defVdcIntPrec;}
  132.   virtual realPrec& vdcRealPrec() 
  133.     {return vdcRealPrecCmd ? vdcRealPrecCmd->thisPrec :
  134.      defVdcRealPrecCmd ? defVdcRealPrecCmd->thisPrec : defVdcRealPrec;}
  135.   ////
  136.   static const int cgmNoClasses; // size of parsing array
  137.   // get a polygon set
  138.   virtual void polygonSet(vdcPts*&, int*&);
  139. protected:
  140.   static cgmNameNew* cgmNameArray; // parsing info array
  141.   static int beginPictureIndex, endMetafileIndex;
  142.   static void initNameArray(); // initialize the name array
  143.   virtual int sameCmd(const cgmNameNew&) = 0; // match the command
  144.   // local flags
  145.   int inputError; // did we get an error ?
  146.   static const int noErrors;
  147.   static const int noSep;
  148.   static const int skipParen;
  149. };
  150. ////
  151. // the basic clear text info, used for input parsing and output
  152. ////
  153. class clearInfo {
  154. protected:
  155.   static const char termChar, termChar1, quoteChar, quoteChar1, sepChar,
  156.   sepChar1, sepChar2, sepChar3, sepChar4, sepChar5, sepChar6, nullChar,
  157.   nullChar1, commentChar; // the constant values, defined in cgmio.cc
  158.   int isTerm(const char c) {return (c==termChar)||(c==termChar1);}
  159.   int isQuote(const char c) {return (c==quoteChar)||(c==quoteChar1);}
  160.   int isSep(const char c) {return (c==sepChar) || (c==sepChar6) ||
  161.                     ((c>=sepChar1) && (c<=sepChar5));}
  162.   int isNull(const char c) {return (c==nullChar)||(c==nullChar1);}
  163.   int isComment(const char c) {return (c==commentChar);}
  164. };
  165. ////
  166. // input class for clear text
  167. ////
  168. class clearInput : public cgmInput, public clearInfo {
  169. public:
  170.   clearInput(const char *inName, short refHand=0)
  171.      : cgmInput(inName, refHand) {}
  172.   clearInput(FILE *inPtr, short refHand=0, int offset=0)
  173.      : cgmInput(inPtr, refHand, offset) {}
  174.   // the required functions
  175.   virtual int isa() {return clearCGM;}
  176. #if __MSDOS__
  177.   virtual HugePt getCmd();
  178. #else
  179.   virtual unsigned char *getCmd();
  180. #endif
  181.   virtual char *getString(int&);
  182.   virtual int getInt(int = 0);
  183.   virtual float getReal();
  184.   virtual float getFP() {return getReal();}
  185.   virtual int getType(const char**, int);
  186.   virtual void getIntPrec(intPrec*);
  187.   virtual void getIntPrec(uIntPrec*);
  188.   virtual void getRealPrec(realPrec*);
  189.   virtual unsigned int getCD(int flag = 0) {return getInt(flag);}
  190.   virtual unsigned int getCI(int flag = 0) {return getInt(flag);}
  191.   virtual int getVIP() {return getInt();}
  192.   virtual float getVRP() {return getReal();}
  193.   virtual int getE() {return getInt();}
  194.   virtual int getNoDColrs() {return getNoTokens() / 3;}
  195.   virtual cgmDefaults *getDefaults(cgmMetafile*);
  196.   virtual const char *cmdSignature() {return (const char *) buffer;}
  197.   // get a cell array
  198.   virtual cellArray *getCellArray(int, const colrValueExtent*,
  199.                   const colrTable*);
  200.   virtual long thisSize() {return bIndex;}
  201. private:
  202.   virtual int sameCmd(const cgmNameNew &inName)
  203.     {return same(*(inName.myName));}
  204.   virtual int same(const char*);
  205.   int getDecimal();
  206.   long getLongDecimal();
  207.   int getBased(int);
  208.   int getNoTokens();
  209.   virtual int getNoPts();
  210.   virtual int polygonSetSize();
  211.   virtual int getPt(float*);
  212.   virtual int getPt(int*);
  213. };
  214. ////
  215. // input class for binary format
  216. ////
  217. class binaryInput : public cgmInput {
  218. public:
  219.   binaryInput(const char *inName, short refHand=0)
  220.      : cgmInput(inName, refHand) {}
  221.   binaryInput(FILE* inPtr, short refHand=0, int offset=0)
  222.      : cgmInput(inPtr, refHand, offset) {}
  223.   ~binaryInput();
  224.   // required functions
  225.   virtual int isa() {return binaryCGM;}
  226. #if __MSDOS__
  227.   virtual HugePt getCmd();
  228. #else
  229.   virtual unsigned char *getCmd();
  230. #endif
  231.   virtual char *getString(int&);
  232.   virtual int getInt(int = 0) {return gInt(myIntPrec().noBytes);}
  233.   virtual int getShiftInt(int bitShift= 0)
  234.     {return gShiftInt(myIntPrec().noBytes, bitShift);}
  235.   virtual float getReal() {return gReal(myRealPrec());}
  236.   virtual float getFP() {return gFP(myRealPrec());}
  237.   virtual int getType(const char**, int) {return getE();}
  238.   virtual void getIntPrec(intPrec *inPrec)
  239.     {inPrec->noBytes = getInt() / 8;}
  240.   virtual void getIntPrec(uIntPrec *inPrec)
  241.     {inPrec->noBytes = getInt() / 8;}
  242.   virtual void getRealPrec(realPrec*);
  243.   virtual int getE() {return gInt(2);}
  244.   virtual unsigned int getCD(int = 0) {return gUInt(colrPrec().noBytes);}
  245.   virtual unsigned int getCI(int = 0) {return gUInt(colrIndexPrec().noBytes);}
  246.   virtual int getVIP() {return gInt(vdcIntPrec().noBytes);}
  247.   virtual float getVRP() {return gReal(vdcRealPrec());}
  248.   virtual int getNoPts();
  249.   virtual int polygonSetSize();
  250.   virtual int getPt(float*);
  251.   virtual int getPt(int*);
  252.   virtual int getNoDColrs() // how many direct colours to come ?
  253.     {return (bIndex<=aIndex) ? 0 : (bIndex-aIndex)/(3 * colrPrec().noBytes);}
  254.   virtual cgmDefaults *getDefaults(cgmMetafile*);
  255.   virtual const char *cmdSignature();
  256.   virtual int padCmd() {return !(bufferClass() && bufferElement());}
  257.   virtual int sameCmd(const cgmNameNew &inCmd)
  258.     {return (bufferClass() == inCmd.myClass) &&
  259.        (bufferElement() == inCmd.myElement);}
  260.   // get a cell array
  261.   virtual cellArray *getCellArray(int, const colrValueExtent*,
  262.                   const colrTable*);
  263.   virtual long thisSize() {return (bIndex % 2) ? bIndex + 1 : bIndex;}
  264.   // local functions
  265.   unsigned int bufferClass() {return buffer[0] >> 4;}
  266.   unsigned int bufferElement()
  267.     {return ((buffer[0] << 3) & 127) + (buffer[1] >> 5);}
  268. protected:
  269.   unsigned int gUInt(int); // general unsigned integer
  270.   int gInt(int); // general signed integer
  271.   int gShiftInt(int, int); // general shifted signed integer
  272.   float gReal(realPrec &inPrec) // general real
  273.     {return inPrec.format ? gFX(inPrec) : gFP(inPrec);} 
  274.   float gFP(realPrec&); // general floating point real
  275.   float gFX(realPrec&); // general fixed point real
  276. };
  277. ////
  278. // now some derivative binary variations
  279. ////
  280. #define NCARSIZE 1440 /* NCAR comes in chunks this size */
  281. class NCARInput : public binaryInput { // NCAR format
  282. public:
  283.   NCARInput(const char *inName, short refHand=0)
  284.      : binaryInput(inName, refHand) {initialize();}
  285.   NCARInput(FILE *inPtr, short refHand=0, int offset=0)
  286.      : binaryInput(inPtr, refHand, offset) {initialize();}
  287.   virtual int getOffBytes(unsigned int noBytes, unsigned long offset=0);
  288. protected:
  289.   void initialize();
  290.   unsigned char localBuffer[NCARSIZE];
  291.   unsigned int startIndex, endIndex;
  292.   int fillLocalBuffer();
  293. };
  294. class MilInput : public binaryInput { // military format
  295. public:
  296.   MilInput(const char *inName, short refHand=0)
  297.      : binaryInput(inName, refHand) {}
  298.   MilInput(FILE *inPtr, short refHand=0, int offset=560) // 560 = 7 * 80 lines
  299.      : binaryInput(inPtr, refHand, offset) {}
  300. };
  301. class LANLInput : public binaryInput { // LANL format
  302. public:
  303.   LANLInput(const char *inName, short refHand=0)
  304.      : binaryInput(inName, refHand) {}
  305.   LANLInput(FILE *inPtr, short refHand=0, int offset=360)
  306.      : binaryInput(inPtr, refHand, offset) {}
  307. };
  308. ////
  309. // class to hold a complete cgm file
  310. ////
  311. class cgmFile : public basicInput {
  312. public:
  313.   cgmFile(const char *inName = NULL, short file_ref_num = NULL);
  314.   ~cgmFile();
  315.   cgmMetafile *foundMetafile() {return metafile;}
  316.   const char *name() {return inputName;}
  317. private:
  318.   char *inputName;
  319.   int nameSize;
  320.   cgmInput *inputHandler;
  321.   cgmMetafile *metafile;
  322.   cgmInput *getCgmInput();
  323. };
  324. ////
  325. // basic cgm output class
  326. ////
  327. class cgmOutput { 
  328. public:
  329.   virtual int startCmd(baseCGM*) = 0;
  330.   virtual int endCmd() = 0;
  331.   virtual int outString(const char*) = 0;
  332.   virtual int outInt(int, int = 0) = 0;
  333.   virtual int outReal(float) = 0;
  334.   virtual int outType(const char**, int) = 0;
  335.   virtual int outIntPrec(intPrec*) = 0; 
  336.   virtual int outIntPrec(uIntPrec*) = 0; 
  337.   virtual int outRealPrec(realPrec*) = 0; 
  338.   virtual int outDColr(dColr&) = 0; 
  339.   virtual int outVdc(const vdc*) = 0; // output a single VDC
  340.   virtual int outVdcPts(const vdcPts*) = 0; // output a set of VDC points
  341.   virtual int outColr(genColr*) = 0; // output a general colour
  342.   virtual int outCellArray(cellArray*) = 0; // output a cell array
  343.   virtual int polygonSet(const vdcPts*, const int*); // polygon set
  344.   virtual int outColrTable(colrTable*) = 0; // output a colour table
  345.   virtual int outDefaults(cgmDefaults*) = 0; // output set of defaults
  346. };
  347. ////
  348. // output class for clear text
  349. ////
  350. class clearOutput : public cgmOutput, public clearInfo, public basicOutput {
  351. public:
  352.   clearOutput(const char *inName, short ref_num=0)
  353.      : basicOutput(inName, ref_num) {}
  354.   virtual int startCmd(baseCGM*);
  355.   virtual int endCmd();
  356.   int outString(const char*);
  357.   virtual int outInt(int inVal, int noSep = 0)
  358.     {return textIntOut(inVal, noSep);}
  359.   virtual int outReal(float inVal) {return textRealOut(inVal);}
  360.   virtual int outType(const char**, int);
  361.   virtual int outIntPrec(intPrec*); 
  362.   virtual int outIntPrec(uIntPrec*); 
  363.   virtual int outRealPrec(realPrec*);
  364.   virtual int outDColr(dColr&);
  365.   virtual int outVdcPts(const vdcPts*);
  366.   virtual int outVdc(const vdc*);
  367.   virtual int outColr(genColr*);
  368.   virtual int outCellArray(cellArray*);
  369.   virtual int outColrTable(colrTable*);
  370.   virtual int outDefaults(cgmDefaults*);
  371. };
  372. ////
  373. // output class for binary output
  374. ////
  375. class binaryOutput { 
  376. public:
  377.   // the required functions
  378.   virtual int startCmd(baseCGM*);
  379.   virtual int endCmd();
  380.   virtual int outString(const char*);
  381.   virtual int outInt(int, int = 0) = 0;
  382.   virtual int outReal(float) = 0;
  383.   virtual int outType(const char**, int);
  384.   virtual int outIntPrec(intPrec*) = 0; 
  385.   virtual int outIntPrec(uIntPrec*) = 0; 
  386.   virtual int outRealPrec(realPrec*) = 0; 
  387.   virtual int outDColr(dColr&) = 0; 
  388.   virtual int outVdc(const vdc*) = 0; // output a single VDC
  389.   virtual int outVdcPts(const vdcPts*) = 0; // output a set of VDC points
  390.   virtual int outColr(genColr*) = 0; // output a general colour
  391.   virtual int outCellArray(cellArray*) = 0; // output a cell array
  392.   virtual int outColrTable(colrTable*) = 0; // output a colour table
  393.   virtual int outDefaults(cgmDefaults*) = 0; // output set of defaults
  394. protected:
  395.   // binary specific functions
  396. };
  397. #endif /* cgmio_h */
  398.